package com.example.rx.rxtest;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.support.v7.widget.RecyclerView;
import android.util.Log;
import android.widget.Toast;

import com.example.rx.rxtest.dagger.ApplicationModel;
import com.example.rx.rxtest.dagger.DaggerAppComponent;

import java.util.HashMap;
import java.util.logging.Logger;

import javax.inject.Inject;

import rx.Observable;
import rx.Observer;
import rx.Scheduler;
import rx.Subscriber;
import rx.android.schedulers.AndroidSchedulers;
import rx.functions.Action0;
import rx.functions.Action1;
import rx.schedulers.Schedulers;

public class MainActivity extends AppCompatActivity {
    RecyclerView test_list;

    @Inject
    MyApplication mMyApplication;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        test_list = (RecyclerView) findViewById(R.id.test_list);
        getChannel();

    }

    public void getChannel() {
        ApiService apiService = MyApplication.sRetrofit.create(ApiService.class);
        HashMap<String, String> map = new HashMap<>();
        map.put("page", "1");
        map.put("id", "hocks:mobile_index");
        map.put("version", "1");
        map.put("appid", "MALA");
        Observable<String> observable = apiService.getChannelList(map);
        observable.subscribeOn(Schedulers.newThread()).observeOn(AndroidSchedulers.mainThread()).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                Log.i("onCompleted", "-->onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.i("onCompleted", "-->onError" + e.getMessage());
            }

            @Override
            public void onNext(String s) {
                Log.i("response", "--->onNext" + s);
            }
        });

    }

    public void testRxJava1() {
        // 创建被观察者，需要向观察者发射数据
        Observable<String> ob = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                // 发射数据
                // 持有观察者对象，在这里调用观察者回调方法
                subscriber.onNext("a");
                subscriber.onNext("b");
                subscriber.onNext("c");
                subscriber.onCompleted();
            }
        });
        // 创建观察者，监控被观察者的动态，比如有数据发射过来：这里Subscriber和Observer几乎等价
        Subscriber<String> sb = new Subscriber<String>() {
            @Override
            public void onCompleted() {
                // 当事件队列中的所有事件都处理完成后，调用该方法
            }

            @Override
            public void onError(Throwable e) {
                // 处理事件队列的过程中出现错误，停止onNext方法的调用
            }

            @Override
            public void onNext(String s) {
                // 处理发射过来的数据，有可能多次调用，也就是一个事件队列
            }
        };
        ob.subscribeOn(Schedulers.io());// 在io线程处理数据发射（读写文件、读写数据库、网络信息交互等），比如网络请求获取数据然后发射个观察者
        ob.observeOn(AndroidSchedulers.mainThread());// 在ui线程处理回调，拿到数据后我能做些什么
        ob.subscribe(sb);// 进行订阅，也就是通过被观察OnSubscribe对象调用它的call方法，进行数据发射
    }

    public void testRxJava2() {
        // 创建被观察者，需要向观察者发射数据
        Observable<String> ob = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                // 持有观察者对象，在这里调用观察者回调方法
                subscriber.onNext("a");
                subscriber.onNext("b");
                subscriber.onNext("c");
                subscriber.onCompleted();
            }
        });
        // 创建不完全的订阅者（观察者），Action1接口的call带参数，可以生成残缺版的Subscriber
        // 当前定义正常的泛型，可以作为观察者的onNext方法
        Action1<String> nextAction = new Action1<String>() {
            @Override
            public void call(String s) {

            }
        };
        // 创建不完全的订阅者（观察者），Action1接口的call带参数，可以生成残缺版的Subscriber
        //  当前定义异常的泛型，可以作为观察者的onError方法
        Action1<Throwable> errorAction = new Action1<Throwable>() {
            @Override
            public void call(Throwable throwable) {

            }
        };
        // 创建不完全的订阅者（观察者），Action0接口的call没有参数，可以生成残缺版的Subscriber
        //  可以作为观察者的onError方法
        Action0 completeAction = new Action0() {
            @Override
            public void call() {

            }
        };
        ob.subscribeOn(Schedulers.io());// 在io线程处理数据发射，比如网络请求获取数据然后发射个观察者
        ob.observeOn(AndroidSchedulers.mainThread());// 在ui线程处理回调，拿到数据后我能做些什么
        ob.subscribe(nextAction, errorAction, completeAction);// 这样就是一个完整的观察者
    }

}
